AI Systems Evolution | Shubham Prajapati

Why this exists

Everyone uses the words: workflow, agent, multi-agent, swarm - and almost nobody agrees on where one ends and the next begins. This repo settles it by showing instead of telling. The same task runs at six levels of autonomy. The lesson is the diff between the rungs.

It is also the front door to everything else in this open-source stack. Read the ladder, then follow the links down into the production-grade repos.

The six rungs

00 Plain code. No model. A human wrote every word of the logic. The output is generic regardless of the topic. This is the baseline everything else is measured against.
01 Single LLM call. One prompt, one completion, done. We added intelligence, but the system gets one shot: no tools, no memory, no second step.
02 Workflow. A fixed chain of LLM calls: outline → draft → polish. More reliable than one call, but a human wrote the path. The system cannot deviate. This is the rung most people call “AI”.
03 Agent. LLM + tools + a loop. Now the model decides what to do next. Nobody wrote the path: the agent picks it at runtime based on what it finds. This is where autonomy begins.
04 Agentic team. Several agents with different roles: planner, worker, reviewer. They share a blackboard (common state) and an orchestrator decides who acts when. Division of labor, with handoffs.
05 Swarm. Many peer agents, no central boss. Each works independently, then sees the others’ output and adjusts. Coordination emerges, nobody directed it.

The two lines people always blur

Workflow vs Agent (rung 02 → 03). A workflow runs LLM calls on a path a human wrote. An agent lets the model choose the path at runtime. The two ingredients that flip it: tools (something to act with) and a loop (more than one step).

Team vs Swarm (rung 04 → 05). A team has someone in charge: an orchestrator assigns roles and ordering. A swarm has no central control. Coordination emerges from peers reacting to peers.

How to run it

Node 18+, no npm install, no API keys. Everything runs offline in mock mode by default:

node 00-plain-code/main.js
node 01-single-llm-call/main.js
node 02-workflow/main.js
node 03-agent/main.js
node 04-agentic-team/main.js
node 05-swarm/main.js

# Real model (Ollama, free):
LLM_MOCK=0 node 03-agent/main.js

# Change the task for all rungs at once:
TOPIC="the rise of the transistor" node 05-swarm/main.js

Where this fits in the stack

This is the entry point. Once you understand the ladder, the other repos make immediate sense: **[Agent-Anatomy](https://github.com/shubham0086/Agent-Anatomy)** zooms into rung 03 (what one agent is made of), Agentic Patterns documents the architecture theory, Agentic Systems gives you five production-grade runnable agents (rung 04), and AgentKernel is the infra underneath all of them.